/**
 * 模块自动发现工具
 * 自动扫描 /miaoma/ 下的所有模块路由配置
 */

export interface ModuleRoute {
  path: string
  name: string
  component?: any
  meta?: {
    title: string
    icon?: string
    keepAlive?: boolean
    [key: string]: any
  }
  children?: ModuleRoute[]
}

export interface ModuleConfig {
  moduleName: string
  routes: ModuleRoute[]
  menuItems: ModuleRoute[]
  /** 是否在动态菜单中显示 */
  showInDynamicMenu: boolean
}

/**
 * 自动发现所有模块的路由配置
 */
export async function discoverModules(): Promise<ModuleConfig[]> {
  const modules: ModuleConfig[] = []

  // 使用 Vite 的 import.meta.glob 动态扫描所有模块的路由文件
  const routeModules = import.meta.glob('@/miaoma/*/route.ts')

  for (const [path, importFn] of Object.entries(routeModules)) {
    try {
      // 从路径中提取模块名
      // 路径格式: /src/miaoma/moduleName/route.ts
      const moduleName = path.match(/\/([^/]+)\/route\.ts$/)?.[1]

      if (!moduleName) {
        console.warn(`无法从路径 ${path} 中提取模块名`)
        continue
      }

      // 动态导入模块的路由配置
      const routeModule = await importFn() as any

      let routes: ModuleRoute[] = []

      // 处理不同的导出格式
      if (routeModule.default) {
        routes = Array.isArray(routeModule.default) ? routeModule.default : [routeModule.default]
      } else {
        // 查找命名导出（如 studentRoutes, configRoutes 等）
        const exportKeys = Object.keys(routeModule).filter(key => key.includes('Routes') || key.includes('routes'))
        if (exportKeys.length > 0) {
          routes = routeModule[exportKeys[0]]
        }
      }

      // 尝试读取模块的 data.ts 配置中的 showInDynamicMenu
      let showInDynamicMenu = true // 默认显示

      try {
        const dataPath = path.replace('/route.ts', '/data.ts')
        const dataModules = import.meta.glob('@/miaoma/*/data.ts')
        const dataImportFn = dataModules[dataPath]

        if (dataImportFn) {
          const dataModule = await dataImportFn() as any

          // 读取 flags.showInDynamicMenu 配置
          if (dataModule.flags && typeof dataModule.flags.showInDynamicMenu === 'boolean') {
            showInDynamicMenu = dataModule.flags.showInDynamicMenu
          }
        }
      } catch (error) {
        console.warn(`读取模块 ${moduleName} 的 data.ts 配置失败:`, error)
        // 继续使用默认配置
      }

      if (routes.length > 0) {
        modules.push({
          moduleName,
          routes,
          menuItems: extractMenuItems(routes, moduleName),
          showInDynamicMenu
        })
      }
    } catch (error) {
      console.warn(`无法加载模块路由配置 ${path}:`, error)
    }
  }

  return modules
}

/**
 * 从路由配置中提取菜单项
 */
function extractMenuItems(routes: ModuleRoute[], moduleName: string): ModuleRoute[] {
  const menuItems: ModuleRoute[] = []

  routes.forEach(route => {
    // 跳过父级容器路由，直接提取子路由作为菜单项
    if (route.children && route.children.length > 0) {
      route.children.forEach(child => {
        // 只有明确标记为 showInMenu: true 的路由才会生成菜单项
        if (child.meta && child.meta.title && child.meta.showInMenu === true) {
          menuItems.push({
            ...child,
            // 清理路径，移除开头的斜杠
            path: cleanPath(child.path)
          })
        }
      })
    } else if (route.meta && route.meta.title && route.meta.showInMenu === true) {
      // 如果是扁平结构，直接使用该路由（也需要检查 showInMenu 标识）
      menuItems.push({
        ...route,
        path: cleanPath(route.path)
      })
    }
  })

  return menuItems
}

/**
 * 清理路径 - 移除开头的斜杠，让路径适合作为子路由
 */
function cleanPath(path: string): string {
  return path.startsWith('/') ? path.substring(1) : path
}

/**
 * 自动生成扁平化的路由配置
 */
export function generateFlatRoutes(modules: ModuleConfig[]): ModuleRoute[] {
  const flatRoutes: ModuleRoute[] = []

  modules.forEach(module => {
    module.routes.forEach(route => {
      if (route.children && route.children.length > 0) {
        // 将所有子路由提升为顶级路由（包括不显示在菜单中的）
        route.children.forEach(child => {
          flatRoutes.push({
            ...child,
            path: cleanPath(child.path),
            // 确保路由名称唯一
            name: child.name || `${module.moduleName}Route`
          })
        })
      } else {
        flatRoutes.push({
          ...route,
          path: cleanPath(route.path),
          name: route.name || `${module.moduleName}Route`
        })
      }
    })
  })

  return flatRoutes
}